// 用户控制器
const { User } = require('../models');
const { Op } = require('sequelize');
const PasswordUtils = require('../utils/passwordUtils');
const JwtUtils = require('../utils/jwtUtils');

/**
 * 用户控制器
 * 处理用户相关的业务逻辑
 */
class UserController {
  /**
   * 用户登录
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   */
  static async login(req, res) {
    try {
      const { username, password, role } = req.body;

      // 验证输入
      if (!username || !password || !role) {
        return res.status(400).json({
          success: false,
          message: '请输入用户名、密码和用户类型'
        });
      }

      // 查找用户
      const user = await User.findOne({
        where: { username, role },
        include: [{ model: User.associations.classInfo.target, as: 'classInfo' }]
      });

      if (!user) {
        return res.status(401).json({
          success: false,
          message: '用户名或密码错误'
        });
      }

      // 验证密码
      const isPasswordValid = await PasswordUtils.verifyPassword(password, user.password);
      if (!isPasswordValid) {
        return res.status(401).json({
          success: false,
          message: '用户名或密码错误'
        });
      }

      // 生成JWT令牌
      const token = JwtUtils.generateToken({
        id: user.id,
        username: user.username,
        role: user.role,
        classId: user.classId
      });

      // 返回用户信息和令牌
      res.json({
        success: true,
        message: '登录成功',
        data: {
          token,
          user: {
            id: user.id,
            username: user.username,
            name: user.name,
            role: user.role,
            classId: user.classId,
            className: user.classInfo?.className
          }
        }
      });
    } catch (error) {
      console.error('登录失败:', error);
      res.status(500).json({
        success: false,
        message: '服务器内部错误'
      });
    }
  }

  /**
   * 修改密码
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   */
  static async changePassword(req, res) {
    try {
      const { oldPassword, newPassword } = req.body;
      const userId = req.user.id;

      // 验证输入
      if (!oldPassword || !newPassword) {
        return res.status(400).json({
          success: false,
          message: '请输入旧密码和新密码'
        });
      }

      // 查找用户
      const user = await User.findByPk(userId);
      if (!user) {
        return res.status(404).json({
          success: false,
          message: '用户不存在'
        });
      }

      // 验证旧密码
      const isPasswordValid = await PasswordUtils.verifyPassword(oldPassword, user.password);
      if (!isPasswordValid) {
        return res.status(400).json({
          success: false,
          message: '旧密码错误'
        });
      }

      // 加密新密码
      const hashedPassword = await PasswordUtils.hashPassword(newPassword);

      // 更新密码
      await user.update({ password: hashedPassword });

      res.json({
        success: true,
        message: '密码修改成功'
      });
    } catch (error) {
      console.error('修改密码失败:', error);
      res.status(500).json({
        success: false,
        message: '服务器内部错误'
      });
    }
  }

  /**
   * 获取用户信息
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   */
  static async getUserInfo(req, res) {
    try {
      const userId = req.user.id;

      // 查找用户
      const user = await User.findOne({
        where: { id: userId },
        include: [{ model: User.associations.classInfo.target, as: 'classInfo' }],
        attributes: ['id', 'username', 'name', 'role', 'classId']
      });

      if (!user) {
        return res.status(404).json({
          success: false,
          message: '用户不存在'
        });
      }

      res.json({
        success: true,
        data: {
          id: user.id,
          username: user.username,
          name: user.name,
          role: user.role,
          classId: user.classId,
          className: user.classInfo?.className
        }
      });
    } catch (error) {
      console.error('获取用户信息失败:', error);
      res.status(500).json({
        success: false,
        message: '服务器内部错误'
      });
    }
  }

  /**
   * 注册用户（教师创建学生账户）
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   */
  static async register(req, res) {
    try {
      const { username, password, role, classId, name } = req.body;

      // 验证输入
      if (!username || !password || !role) {
        return res.status(400).json({
          success: false,
          message: '请输入用户名、密码和用户类型'
        });
      }

      // 学生必须指定班级
      if (role === 'student' && !classId) {
        return res.status(400).json({
          success: false,
          message: '学生必须指定班级'
        });
      }

      // 检查用户是否已存在
      const existingUser = await User.findOne({
        where: { username, role }
      });

      if (existingUser) {
        return res.status(400).json({
          success: false,
          message: '用户已存在'
        });
      }

      // 加密密码
      const hashedPassword = await PasswordUtils.hashPassword(password);

      // 创建用户
      const user = await User.create({
        username,
        password: hashedPassword,
        role,
        name, // 保存学生姓名
        classId: role === 'student' ? classId : null
      });

      res.json({
        success: true,
        message: '用户创建成功',
        data: {
          id: user.id,
          username: user.username,
          name: user.name,
          role: user.role,
          classId: user.classId
        }
      });
    } catch (error) {
      console.error('创建用户失败:', error);
      res.status(500).json({
        success: false,
        message: '服务器内部错误'
      });
    }
  }

  /**
   * 重置学生密码
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   */
  static async resetPassword(req, res) {
    try {
      const { userId } = req.params;

      // 查找用户
      const user = await User.findByPk(userId);
      if (!user) {
        return res.status(404).json({
          success: false,
          message: '用户不存在'
        });
      }

      // 确保只能重置学生密码
      if (user.role !== 'student') {
        return res.status(403).json({
          success: false,
          message: '只能重置学生密码'
        });
      }

      // 加密默认密码 '123456'
      const hashedPassword = await PasswordUtils.hashPassword('123456');

      // 更新密码
      await user.update({ password: hashedPassword });

      res.json({
        success: true,
        message: '密码重置成功，新密码为123456'
      });
    } catch (error) {
      console.error('重置密码失败:', error);
      res.status(500).json({
        success: false,
        message: '服务器内部错误'
      });
    }
  }

  /**
   * 删除用户
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   */
  static async deleteUser(req, res) {
    try {
      const { userId } = req.params;

      // 查找用户
      const user = await User.findByPk(userId);
      if (!user) {
        return res.status(404).json({
          success: false,
          message: '用户不存在'
        });
      }

      // 删除用户
      await user.destroy();

      res.json({
        success: true,
        message: '用户删除成功'
      });
    } catch (error) {
      console.error('删除用户失败:', error);
      res.status(500).json({
        success: false,
        message: '服务器内部错误'
      });
    }
  }

  /**
   * 获取学生列表（支持分页）
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   */
  static async getStudents(req, res) {
    try {
      const { class_id, search, page = 1, pageSize = 10 } = req.query;
      
      // 构建查询条件
      const whereClause = { role: 'student' };
      
      // 如果指定了班级，添加班级过滤条件
      if (class_id) {
        whereClause.classId = class_id;
      }
      
      // 如果指定了搜索关键词，添加搜索条件（同时搜索学号和姓名）
      if (search) {
        whereClause[Op.or] = [
          { username: { [Op.like]: `%${search}%` } },
          { name: { [Op.like]: `%${search}%` } }
        ];
      }
      
      // 计算分页参数
      const pageNum = parseInt(page) || 1;
      const size = parseInt(pageSize) || 10;
      const offset = (pageNum - 1) * size;
      
      // 查询总数
      const total = await User.count({
        where: whereClause
      });
      
      // 查询学生列表，并包含班级信息
      const students = await User.findAll({
        where: whereClause,
        include: [{ 
          model: User.associations.classInfo.target, 
          as: 'classInfo',
          attributes: ['className']
        }],
        attributes: ['id', 'username', 'name', 'classId', 'role', 'createdAt'],
        limit: size,
        offset: offset,
        order: [['createdAt', 'DESC']] // 按创建时间倒序
      });
      
      // 格式化数据，添加class_name字段，使用数据库中的name字段
      const formattedStudents = students.map(student => {
        const studentData = student.toJSON();
        return {
          ...studentData,
          class_name: studentData.classInfo?.className
        };
      });
      
      res.json({
        success: true,
        data: {
          students: formattedStudents,
          total: total,
          page: pageNum,
          pageSize: size,
          totalPages: Math.ceil(total / size)
        }
      });
    } catch (error) {
      console.error('获取学生列表失败:', error);
      res.status(500).json({
        success: false,
        message: '服务器内部错误'
      });
    }
  }
}

module.exports = UserController;